/*
 * @Author: wei_jt
 * @Date: 2019-11-01 16:43:30
 * @LastEditors: wei_jt
 * @LastEditTime: 2020-12-29 10:38:52
 * @Description: 工具类，根据功能划分
 */
//判断数据是否为json
export function isJSON(str) {
	if (typeof str == 'string') {
		try {
			let obj = JSON.parse(str);
			if (typeof obj == 'object' && obj) {
				return true;
			} else {
				return false;
			}
		} catch (e) {
			return false;
		}
	}
}
/**
 * @description: 解析列表为树形
 * @param {Array} data 原始列表
 * @param {String} idName id标识值
 * @param {String} pidName pid标识值
 * @return: val 树形列表 map 对应map
 */
export function transTree(data, idName, pidName) {
	data.forEach((item) => {
		delete item.children;
	});
	// 将数据存储为 以 id 为 KEY 的 map 索引数据列
	let map = {};
	data.forEach((item) => {
		map[item[idName]] = item;
	});
	let val = [];
	data.forEach((item) => {
		// 以当前遍历项，的pid,去map对象中找到索引的id
		let parent = map[item[pidName]];
		// 好绕啊，如果找到索引，那么说明此项不在顶级当中,那么需要把此项添加到，他对应的父级中
		if (parent) {
			(parent.children || (parent.children = [])).push(item);
		} else {
			// 如果没有在map中找到对应的索引ID,那么直接把 当前的item添加到 val结果集中，作为顶级
			val.push(item);
		}
	});
	return {
		val,
		map
	};
}

/**
 * @description: 执行js表达式，兼容性实现eval()
 * @param {type}
 * @return:
 */
export function evil(fn) {
	let Fn = Function; // 一个变量指向Function，防止有些前端编译工具报错
	return new Fn('return ' + fn)();
}

/**
 * @description 生成UUID
 * @param {Integer} len uuid长度
 * @param {Integer} radix uuid基数
 * @returns {String} UUID
 */
export function uuid(len, radix) {
	let chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split('');
	let uuid = [],
		i;
	radix = radix || chars.length;

	if (len) {
		// Compact form
		for (i = 0; i < len; i++) uuid[i] = chars[0 | (Math.random() * radix)];
	} else {
		// rfc4122, version 4 form
		let r;
		// rfc4122 requires these characters
		uuid[8] = uuid[13] = uuid[18] = uuid[23] = '-';
		uuid[14] = '4';
		// Fill in random data.  At i==19 set the high bits of clock sequence as
		// per rfc4122, sec. 4.1.5
		for (i = 0; i < 36; i++) {
			if (!uuid[i]) {
				r = 0 | (Math.random() * 16);
				uuid[i] = chars[i == 19 ? (r & 0x3) | 0x8 : r];
			}
		}
	}
	return uuid.join('');
}

/**
 * @description: 获取url中的query
 * @param {variable} 需要获取的key值
 */
export function getQueryVariable(variable) {
	let rawQuery =
		(window.location.search ? window.location.search.substring(1) : '') ||
		window.location.href.split('?')[1];
	if (!!!rawQuery) {
		return null;
	}
	let reg = new RegExp('(^|&)' + variable + '=([^&]*)(&|$)');
	let r = rawQuery.match(reg); //search,查询？后面的参数，并匹配正则
	if (r != null) {
		return unescape(r[2]);
	}
	return null;
}

/**
 * @description: 获取url参数对象或字符串
 * @param {String} url
 * @param {String} 指定参数
 * @return {type}
 */
export function getParamByUrl(url, par) {
	let fileUrl = ''; //文件地址
	let listParam = ''; //参数集合
	let listParamObj = {}; //
	let listParamArr = ''; //包含所有参数
	//去掉hash
	url = url.replace('#', '');
	//获取文件地址
	fileUrl = url.split('?')[0];
	listParam = url.split('?');
	if (listParam.length > 1) {
		listParam.shift();
		let listParam2 = listParam.join();
		listParamArr = listParam2.split('&');
		listParamArr.forEach(function (ele) {
			let temp = ele.split('=');
			listParamObj[temp[0]] = temp[1];
		});
	} else {
		console.log('没有参数');
	}
	if (par == 'all') {
		//返回全部参数
		return listParamObj;
	} else {
		//返回指定参数
		for (const key in listParamObj) {
			if (key == par) {
				return JSON.parse('{' + '"' + par + '"' + ':' + '"' + listParamObj[par] + '"' + '}');
			} else {
				console.log('没有传入的参数');
			}
		}
	}
}

// 首字母大小
export function titleCase(str) {
	return str.replace(/( |^)[a-z]/g, (L) => L.toUpperCase());
}

// 下划转驼峰
export function camelCase(str) {
	return str.replace(/-[a-z]/g, (str1) => str1.substr(-1).toUpperCase());
}

function stringify(obj) {
	return JSON.stringify(obj, (key, val) => {
		if (typeof val === 'function') {
			return `${val}`;
		}
		return val;
	});
}

function parse(str) {
	JSON.parse(str, (k, v) => {
		if (v.indexOf && v.indexOf('function') > -1) {
			return eval(`(${v})`);
		}
		return v;
	});
}

export function jsonClone(obj) {
	return parse(stringify(obj));
}

// 深拷贝对象
export function deepClone(obj) {
	const _toString = Object.prototype.toString;

	// null, undefined, non-object, function
	if (!obj || typeof obj !== 'object') {
		return obj;
	}

	// DOM Node
	if (obj.nodeType && 'cloneNode' in obj) {
		return obj.cloneNode(true);
	}

	// Date
	if (_toString.call(obj) === '[object Date]') {
		return new Date(obj.getTime());
	}

	// RegExp
	if (_toString.call(obj) === '[object RegExp]') {
		const flags = [];
		if (obj.global) {
			flags.push('g');
		}
		if (obj.multiline) {
			flags.push('m');
		}
		if (obj.ignoreCase) {
			flags.push('i');
		}

		return new RegExp(obj.source, flags.join(''));
	}

	const result = Array.isArray(obj) ? [] : obj.constructor ? new obj.constructor() : {};

	for (const key in obj) {
		result[key] = deepClone(obj[key]);
	}

	return result;
}
